{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling and Simulation in Python\n",
    "\n",
    "Chapter 4\n",
    "\n",
    "Copyright 2017 Allen Downey\n",
    "\n",
    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Configure Jupyter so figures appear in the notebook\n",
    "%matplotlib inline\n",
    "\n",
    "# Configure Jupyter to display the assigned value after an assignment\n",
    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
    "\n",
    "# import functions from the modsim library\n",
    "from modsim import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Returning values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a simple function that returns a value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_five(x):\n",
    "    return x + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here's how we call it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = add_five(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you run a function on the last line of a cell, Jupyter displays the result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_five(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But that can be a bad habit, because usually if you call a function and don't assign the result in a variable, the result gets discarded.\n",
    "\n",
    "In the following example, Jupyter shows the second result, but the first result just disappears."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_five(3)\n",
    "add_five(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you call a function that returns a variable, it is generally a good idea to assign the result to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 10\n"
     ]
    }
   ],
   "source": [
    "y1 = add_five(3)\n",
    "y2 = add_five(5)\n",
    "\n",
    "print(y1, y2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Write a function called `make_state` that creates a `State` object with the state variables `olin=10` and `wellesley=2`, and then returns the new `State` object.\n",
    "\n",
    "Write a line of code that calls `make_state` and assigns the result to a variable named `init`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution\n",
    "\n",
    "def make_state():\n",
    "    state = State(olin=10, wellesley=2)\n",
    "    return state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         10\n",
       "wellesley     2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "init = make_state()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running simulations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's the code from the previous notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def step(state, p1, p2):\n",
    "    \"\"\"Simulate one minute of time.\n",
    "    \n",
    "    state: bikeshare State object\n",
    "    p1: probability of an Olin->Wellesley customer arrival\n",
    "    p2: probability of a Wellesley->Olin customer arrival\n",
    "    \"\"\"\n",
    "    if flip(p1):\n",
    "        bike_to_wellesley(state)\n",
    "    \n",
    "    if flip(p2):\n",
    "        bike_to_olin(state)\n",
    "        \n",
    "def bike_to_wellesley(state):\n",
    "    \"\"\"Move one bike from Olin to Wellesley.\n",
    "    \n",
    "    state: bikeshare State object\n",
    "    \"\"\"\n",
    "    if state.olin == 0:\n",
    "        state.olin_empty += 1\n",
    "        return\n",
    "    state.olin -= 1\n",
    "    state.wellesley += 1\n",
    "    \n",
    "def bike_to_olin(state):\n",
    "    \"\"\"Move one bike from Wellesley to Olin.\n",
    "    \n",
    "    state: bikeshare State object\n",
    "    \"\"\"\n",
    "    if state.wellesley == 0:\n",
    "        state.wellesley_empty += 1\n",
    "        return\n",
    "    state.wellesley -= 1\n",
    "    state.olin += 1\n",
    "    \n",
    "def decorate_bikeshare():\n",
    "    \"\"\"Add a title and label the axes.\"\"\"\n",
    "    decorate(title='Olin-Wellesley Bikeshare',\n",
    "             xlabel='Time step (min)', \n",
    "             ylabel='Number of bikes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a modified version of `run_simulation` that creates a `State` object, runs the simulation, and returns the `State` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_simulation(p1, p2, num_steps):\n",
    "    \"\"\"Simulate the given number of time steps.\n",
    "    \n",
    "    p1: probability of an Olin->Wellesley customer arrival\n",
    "    p2: probability of a Wellesley->Olin customer arrival\n",
    "    num_steps: number of time steps\n",
    "    \"\"\"\n",
    "    state = State(olin=10, wellesley=2, \n",
    "                  olin_empty=0, wellesley_empty=0)\n",
    "                    \n",
    "    for i in range(num_steps):\n",
    "        step(state, p1, p2)\n",
    "        \n",
    "    return state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now `run_simulation` doesn't plot anything:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>olin_empty</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley_empty</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin                1\n",
       "wellesley          11\n",
       "olin_empty          2\n",
       "wellesley_empty     2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = run_simulation(0.4, 0.2, 60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But after the simulation, we can read the metrics from the `State` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state.olin_empty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can run simulations with different values for the parameters.  When `p1` is small, we probably don't run out of bikes at Olin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = run_simulation(0.2, 0.2, 60)\n",
    "state.olin_empty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When `p1` is large, we probably do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = run_simulation(0.6, 0.2, 60)\n",
    "state.olin_empty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More for loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`linspace` creates a NumPy array of equally spaced numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.  , 0.25, 0.5 , 0.75, 1.  ])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1_array = linspace(0, 1, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use an array in a `for` loop, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "0.25\n",
      "0.5\n",
      "0.75\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "for p1 in p1_array:\n",
    "    print(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will come in handy in the next section.\n",
    "\n",
    "`linspace` is defined in `modsim.py`.  You can get the documentation using `help`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function linspace in module modsim.modsim:\n",
      "\n",
      "linspace(start, stop, num=50, **options)\n",
      "    Returns an array of evenly-spaced values in the interval [start, stop].\n",
      "    \n",
      "    start: first value\n",
      "    stop: last value\n",
      "    num: number of values\n",
      "    \n",
      "    Also accepts the same keyword arguments as np.linspace.  See\n",
      "    https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html\n",
      "    \n",
      "    returns: array or Quantity\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(linspace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`linspace` is based on a NumPy function with the same name.  [Click here](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html) to read more about how to use it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** \n",
    "Use `linspace` to make an array of 10 equally spaced numbers from 1 to 10 (including both)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "linspace(1, 10, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** The `modsim` library provides a related function called `linrange`.  You can view the documentation by running the following cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function linrange in module modsim.modsim:\n",
      "\n",
      "linrange(start=0, stop=None, step=1, endpoint=False, **options)\n",
      "    Returns an array of evenly-spaced values in an interval.\n",
      "    \n",
      "    By default, the last value in the array is `stop-step`\n",
      "    (at least approximately).\n",
      "    If you provide the keyword argument `endpoint=True`,\n",
      "    the last value in the array is `stop`.\n",
      "    \n",
      "    This function works best if the space between start and stop\n",
      "    is divisible by step; otherwise the results might be surprising.\n",
      "    \n",
      "    start: first value\n",
      "    stop: last value\n",
      "    step: space between values\n",
      "    \n",
      "    returns: NumPy array\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(linrange)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `linrange` to make an array of numbers from 1 to 11 with a step size of 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  5,  7,  9, 11])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "linrange(1, 11, 2, endpoint=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sweeping parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`p1_array` contains a range of values for `p1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2 = 0.2\n",
    "num_steps = 60\n",
    "p1_array = linspace(0, 1, 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following loop runs a simulation for each value of `p1` in `p1_array`; after each simulation, it prints the number of unhappy customers at the Olin station:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 0\n",
      "0.1 0\n",
      "0.2 0\n",
      "0.30000000000000004 4\n",
      "0.4 0\n",
      "0.5 14\n",
      "0.6000000000000001 5\n",
      "0.7000000000000001 23\n",
      "0.8 31\n",
      "0.9 32\n",
      "1.0 39\n"
     ]
    }
   ],
   "source": [
    "for p1 in p1_array:\n",
    "    state = run_simulation(p1, p2, num_steps)\n",
    "    print(p1, state.olin_empty)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can do the same thing, but storing the results in a `SweepSeries` instead of printing them.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "sweep = SweepSeries()\n",
    "\n",
    "for p1 in p1_array:\n",
    "    state = run_simulation(p1, p2, num_steps)\n",
    "    sweep[p1] = state.olin_empty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And then we can plot the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(sweep, label='Olin')\n",
    "\n",
    "decorate(title='Olin-Wellesley Bikeshare',\n",
    "         xlabel='Arrival rate at Olin (p1 in customers/min)', \n",
    "         ylabel='Number of unhappy customers')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "**Exercise:** Wrap this code in a function named `sweep_p1` that takes an array called `p1_array` as a parameter.  It should create a new `SweepSeries`, run a simulation for each value of `p1` in `p1_array`, store the results in the `SweepSeries`, and return the `SweepSeries`.\n",
    "\n",
    "Use your function to plot the number of unhappy customers at Olin as a function of `p1`.  Label the axes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution\n",
    "\n",
    "def sweep_p1(p1_array):\n",
    "    p2 = 0.2\n",
    "    num_steps = 60\n",
    "    sweep = SweepSeries()\n",
    "    \n",
    "    for p1 in p1_array:\n",
    "        state = run_simulation(p1, p2, num_steps)\n",
    "        sweep[p1] = state.olin_empty\n",
    "        \n",
    "    return sweep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "p1_array = linspace(0, 1, 101)\n",
    "sweep = sweep_p1(p1_array)\n",
    "plot(sweep, 'bo', label='Olin')\n",
    "decorate(title='Olin-Wellesley Bikeshare',\n",
    "         xlabel='Arrival rate at Olin (p1 in customers/min)', \n",
    "         ylabel='Number of unhappy customers')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Write a function called `sweep_p2` that runs simulations with `p1=0.5` and a range of values for `p2`.  It should store the results in a `SweepSeries` and return the `SweepSeries`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution\n",
    "\n",
    "def sweep_p2(p2_array):\n",
    "    p1 = 0.5\n",
    "    num_steps = 60\n",
    "    sweep = SweepSeries()\n",
    "    \n",
    "    for p2 in p2_array:\n",
    "        state = run_simulation(p1, p2, num_steps)\n",
    "        sweep[p2] = state.olin_empty\n",
    "        \n",
    "    return sweep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "p2_array = linspace(0, 1, 101)\n",
    "sweep = sweep_p2(p2_array)\n",
    "plot(sweep, 'bo', label='Olin')\n",
    "\n",
    "decorate(title='Olin-Wellesley Bikeshare',\n",
    "         xlabel='Arrival rate at Wellesley (p2 in customers/min)', \n",
    "         ylabel='Number of unhappy customers')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optional Exercises\n",
    "\n",
    "The following two exercises are a little more challenging.  If you are comfortable with what you have learned so far, you should give them a try.  If you feel like you have your hands full, you might want to skip them for now.\n",
    "\n",
    "**Exercise:** Because our simulations are random, the results vary from one run to another, and the results of a parameter sweep tend to be noisy.  We can get a clearer picture of the relationship between a parameter and a metric by running multiple simulations with the same parameter and taking the average of the results.\n",
    "\n",
    "Write a function called `run_multiple_simulations` that takes as parameters `p1`, `p2`, `num_steps`, and `num_runs`.\n",
    "\n",
    "`num_runs` specifies how many times it should call `run_simulation`.\n",
    "\n",
    "After each run, it should store the total number of unhappy customers (at Olin or Wellesley) in a `TimeSeries`.  At the end, it should return the `TimeSeries`.\n",
    "\n",
    "Test your function with parameters\n",
    "\n",
    "```\n",
    "p1 = 0.3\n",
    "p2 = 0.3\n",
    "num_steps = 60\n",
    "num_runs = 10\n",
    "```\n",
    "\n",
    "Display the resulting `TimeSeries` and use the `mean` function provided by the `TimeSeries` object to compute the average number of unhappy customers (see Section 2.7)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution\n",
    "\n",
    "def run_multiple_simulations(p1, p2, num_steps, num_runs):\n",
    "    results = TimeSeries()\n",
    "    \n",
    "    for i in range(num_runs):\n",
    "        state = run_simulation(p1, p2, num_steps)\n",
    "        results[i] = state.olin_empty + state.wellesley_empty\n",
    "        \n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "0    0\n",
       "1    0\n",
       "2    0\n",
       "3    0\n",
       "4    4\n",
       "5    2\n",
       "6    0\n",
       "7    4\n",
       "8    4\n",
       "9    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "p1 = 0.3\n",
    "p2 = 0.3\n",
    "num_steps = 60\n",
    "num_runs = 10\n",
    "run_multiple_simulations(p1, p2, num_steps, num_runs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:**  Continuting the previous exercise, use `run_multiple_simulations` to run simulations with a range of values for `p1` and\n",
    "\n",
    "```\n",
    "p2 = 0.3\n",
    "num_steps = 60\n",
    "num_runs = 20\n",
    "```\n",
    "\n",
    "Store the results in a `SweepSeries`, then plot the average number of unhappy customers as a function of `p1`.  Label the axes.\n",
    "\n",
    "What value of `p1` minimizes the average number of unhappy customers?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Solution\n",
    "\n",
    "p1_array = linspace(0, 1, 20)\n",
    "p2 = 0.3\n",
    "num_steps = 60\n",
    "num_runs = 20\n",
    "\n",
    "sweep = SweepSeries()\n",
    "for p1 in p1_array:\n",
    "    results = run_multiple_simulations(p1, p2, num_steps, num_runs)\n",
    "    sweep[p1] = results.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "plot(sweep, label='total', color='green')\n",
    "    \n",
    "decorate(title='Olin-Wellesley Bikeshare',\n",
    "         xlabel='Arrival rate at Olin (p1 in customers/min)', \n",
    "         ylabel='Average total unhappy customers')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
